home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / Application.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  10KB  |  500 lines
  1. //$Application,ApplDialog,ApplIntHandler$
  2.  
  3. #include "ET++.h"
  4.  
  5. #include "Storage.h"
  6. #include "ObjList.h"
  7. #include "IdDictionary.h"
  8. #include "WindowSystem.h"
  9. #include "FileDialog.h"
  10. #include "ObjectTable.h"
  11. #include "ClassManager.h"
  12. #include "ClipBoard.h"
  13. #include "ProgEnv.h"
  14. #include "FixedStorage.h"
  15. #include "Buttons.h"
  16. #include "BorderItems.h"
  17.  
  18. extern char **environ;
  19.  
  20. extern bool gInMain;
  21.  
  22. bool        gBatch= TRUE;
  23. Application *gApplication= 0;
  24. ClipBoard   *gClipBoard;
  25. char        *gProgname;
  26. int         gArgc;
  27. char        **gArgv;
  28. bool        gMemStatistics;
  29.  
  30. static int untitledCnt= 0;
  31.  
  32. extern bool forcemono;
  33.  
  34. //---- ApplIntHandler --------------------------------------------------------------
  35.  
  36. class ApplIntHandler : public SysEvtHandler {
  37. public:
  38.     ApplIntHandler() : SysEvtHandler(eSigInterrupt)
  39.     { }
  40.     void Notify(SysEventCodes, int);
  41. };
  42.  
  43. void ApplIntHandler::Notify(SysEventCodes, int)
  44. {
  45.     if (gApplication)
  46.     gApplication->Inspect();
  47. }
  48.  
  49. static void ApplErrorHandler(int level, bool, char *location, char *msg)
  50. {
  51.     gApplication->DoOnError(level, location, msg);
  52. } 
  53.  
  54. //---- initial Application Dialog ----------------------------------------------
  55.  
  56. MetaImpl(ApplDialog, (TP(appl), 0));
  57.  
  58. ApplDialog::ApplDialog(Application *eh, char *title)
  59.                 : Dialog(title, eBWinDefault+eBWinFixed, eh)
  60. {   
  61.     appl= eh; 
  62. }
  63.  
  64. VObject *ApplDialog::DoCreateDialog() 
  65. {
  66.     return appl->DoCreateDialog();
  67. }
  68.  
  69. void ApplDialog::Control(int id, int p, void *d)
  70. {   
  71.     EvtHandler::Control(id, p, d);    
  72. }
  73.  
  74. Point ApplDialog::GetInitialPos()
  75. {
  76.     return gPoint0;
  77. } 
  78.  
  79. //---- Application -------------------------------------------------------------
  80.  
  81.  
  82. AbstractMetaImpl(Application, (T(argc), TP(documents), TP(menu),
  83.             TP(applDialog), T(lastDocPos), TB(printHierarchy),
  84.             TP(version), TVP(argv, argc), TP(mainDocumentType),
  85.             TP(gClassManager), TP(gObservers), TP(gWindow), T(gScreenRect),
  86.             TPP(gEnviron), TB(gDebug), TB(gBatch), TB(inited), 0));
  87.  
  88. Application::Application(int ac, char **av, const char *dt)
  89. {
  90.     gInMain= TRUE;
  91.     documents= 0;
  92.     menu= 0;
  93.     applDialog= 0;
  94.     clipboard= 0;
  95.     inited= FALSE;
  96.     version= "Version 2.3, 12/1/90, \251IFI & UBS-UBILAB";
  97.  
  98.     if (gApplication)
  99.     Error("Application", "only one Application !!");
  100.     else {
  101.     UpdateGlobals();
  102.     ObjectTable::AddRoot(this);
  103.     SetErrorHandler(ApplErrorHandler);
  104.     gArgc= argc= ac;
  105.     gArgv= argv= av;
  106.     gProgname= argv[0];
  107.     printHierarchy= FALSE;
  108.     lastDocPos= Point(150, 100);
  109.     documents= new ObjList;
  110.     applDialog= 0;
  111.     menu= 0;
  112.     mainDocumentType= dt;
  113.     }
  114. }
  115.  
  116. Application::~Application()
  117. {
  118.     SetErrorHandler(DefaultErrorHandler);
  119.     SafeDelete(documents);
  120.     SafeDelete(applDialog);
  121.     SafeDelete(menu);
  122.  
  123.     if (gMemStatistics) {
  124.     PrintStorageStatistics();
  125.     MemPools::PrintStatistics();
  126.     }
  127. }
  128.  
  129. void Application::ApplInit()
  130. {
  131.     if (! inited) {
  132.     ParseCommandLine(argc, argv);
  133.     ETInit();
  134.     if (printHierarchy)
  135.         gClassManager->DisplayOn(cout);
  136.     inited= TRUE;
  137.     }
  138. }
  139.  
  140. EvtHandler *Application::GetNextHandler()
  141. {
  142.     return 0;
  143. }
  144.  
  145. FileDialog *Application::MakeFileDialog()
  146. {
  147.     return new FileDialog;
  148. }
  149.  
  150. void Application::ParseCommandLine(int argc, char **argv)
  151. {
  152.     int n, i= 1;
  153.     
  154.     while (i < argc) {
  155.     if (argv[i][0] == '-') {
  156.         n= DoParseOptions(argv[i], argv[i+1]);
  157.         if (n >= 0)
  158.         i+= n;
  159.         else
  160.         i++;
  161.     } else {
  162.         ETInit();
  163.         OpenDocument(argv[i]);
  164.         i++;
  165.     }
  166.     }
  167. }
  168.  
  169. int Application::DoParseOptions(char *arg0, char *arg1)
  170. {
  171.     int x= lastDocPos.x, y= lastDocPos.y;
  172.     
  173.     if (arg0[1] != 'E')
  174.     return 0;
  175.  
  176.     switch(arg0[2]) {
  177.     case 'd':   // debug
  178.     ::gDebug= !::gDebug;
  179.     return 1;
  180.     case 'b':   // double buffer
  181.     ::gBatch= !::gBatch;
  182.     return 1;
  183.     case 'c':   // toggle color monochrome
  184.     forcemono= TRUE;
  185.     return 1;
  186.     case 'h':   // print hierarchie to cerr
  187.     printHierarchy= !printHierarchy;
  188.     return 1;
  189.     case 'm':
  190.     ::gMemStatistics= !::gMemStatistics;
  191.     return 1;
  192.     case 'e':
  193.     EditSource(TRUE);
  194.     return 1;
  195.     case 'E':
  196.     gProgEnv->Start();
  197.     return 1;
  198.     case 'w':
  199.     SetIgnoreLevel(0);
  200.     return 1;
  201.     case 'i':
  202.     Inspect();
  203.     return 1;
  204.     case 'p':
  205.     sscanf(arg1, "%d,%d", &x, &y);
  206.     lastDocPos= Point(x,y);
  207.     return 2;
  208.     }
  209.     return 0;
  210. }
  211.  
  212. char *Application::ProgramName()
  213. {
  214.     char *p= rindex(gProgname, '/');
  215.     if (p)
  216.     return p+1;
  217.     return gProgname;
  218. }
  219.  
  220. Point Application::GetNewDocumentPos()
  221. {
  222.     Point p= lastDocPos;
  223.     lastDocPos+= Point(40, 30);
  224.     return p;
  225. }
  226.  
  227. void Application::RemoveDocument(Document *dp)
  228. {
  229.     if (documents)
  230.     documents->Remove(dp);
  231.     gSystem->AddCleanupObject(dp);
  232. }
  233.  
  234. Menu *Application::GetMenu()
  235. {
  236.     if (menu == 0)
  237.     menu= new Menu(argv[0]);
  238.     return menu;
  239. }
  240.  
  241. void Application::About()
  242. {
  243.     ShowAlert(eAlertSun, "%s %s", argv[0], version);
  244. }
  245.  
  246. void Application::HandleApplicationCommands(int cmd)
  247. {
  248.     switch(cmd) {
  249.  
  250.     case cNEW:
  251.     NewDocument(mainDocumentType);
  252.     break;
  253.  
  254.     case cQUIT:
  255.     Quit();
  256.     break;
  257.  
  258.     case cABOUT:
  259.     About();
  260.     break;
  261.  
  262.     case cSHOWAPPLWIN:
  263.     ShowApplicationWindow();
  264.     break;
  265.  
  266.     case cOPEN:
  267.     Open();
  268.     break;
  269.     
  270.     default:
  271.     if (cmd >= cDEBUGFIRST && cmd <= cDEBUGLAST)
  272.         Debug(cmd-cDEBUGFIRST+1);
  273.     }
  274. }
  275.  
  276. Command *Application::DoMenuCommand(int cmd)
  277. {  
  278.     HandleApplicationCommands(cmd);          
  279.     return gNoChanges;
  280. }
  281.  
  282. void Application::Control(int id, int, void*)
  283. { 
  284.     HandleApplicationCommands(id);
  285. }
  286.  
  287. void Application::Quit()
  288. {
  289.     if (CloseAllDocuments())
  290.     gSystem->ExitControl();
  291. }
  292.  
  293. void Application::Debug(int)
  294. {
  295.     gDebug= (::gDebug= ! ::gDebug);
  296. }
  297.  
  298. void Application::Open()
  299. {
  300.     if (fileDialog == 0)
  301.     fileDialog= MakeFileDialog();
  302.     if (fileDialog->ShowInWindow(eFDRead, applDialog->GetWindow(), this) == cIdOk)
  303.     OpenDocument(fileDialog->FileName());
  304. }
  305.  
  306. void Application::AddDocument(Document *dp)
  307. {
  308.     documents->Add(dp);
  309.     dp->SetApplication(this);
  310. }
  311.  
  312. Document *Application::FindDocument(int id)
  313. {
  314.     Document *dp;
  315.     Iter next(documents);
  316.  
  317.     while (dp= (Document*) next())
  318.     if (dp->UniqueId() == id)
  319.         return dp;
  320.     return 0;
  321. }
  322.  
  323. Document *Application::DoMakeDocuments(const char*)
  324. {
  325.     AbstractMethod("DoMakeDocuments");
  326.     return 0;
  327. }
  328.  
  329. bool Application::CloseAllDocuments()
  330. {
  331.     Document *dp;
  332.     Iter next(documents);
  333.  
  334.     while (dp= (Document*) next()) // try to close all documents
  335.     if (! dp->Close())
  336.         return FALSE;
  337.     return TRUE;
  338. }
  339.  
  340. void Application::OpenDocument(char *name)
  341. {
  342.     Document *dp;
  343.     FType ft(name);
  344.  
  345.     if (!CanOpenDocument(ft.FileType())) {
  346.     ShowAlert(eAlertNote, "cannot handle document @I%s@P (%s)\n", name, ft.Type());
  347.     return;
  348.     }
  349.     dp= DoMakeDocuments(ft.Type()); // let user make his documents
  350.     if (dp) {
  351.     AddDocument(dp);
  352.     dp->OpenWindows();
  353.     dp->Load(name, TRUE, ft.FileType());
  354.     }
  355. }
  356.  
  357. void Application::NewDocument(const char *type)
  358. {
  359.     Document *dp;
  360.  
  361.     dp= DoMakeDocuments(type); // let user make his documents
  362.     if (dp == 0) {
  363.     Error("NewDocument", "DoMakeDocuments returns 0");
  364.     return;
  365.     }
  366.     AddDocument(dp);
  367.     dp->SetName(form("untitled.%d", untitledCnt++));
  368.     dp->OpenWindows();
  369. }
  370.  
  371. bool Application::CanOpenDocument(FileType *ft)
  372. {
  373.     if (strismember(mainDocumentType, cDocTypeUndef, ft->Type(), 0))
  374.     return TRUE;
  375.     if (strcmp(mainDocumentType, cDocTypeAscii) == 0 && ft->IsAscii())
  376.     return TRUE;
  377.     return FALSE;
  378. }
  379.  
  380. int Application::Run()
  381. {
  382.     ApplInit();
  383.     
  384.     applDialog= new ApplDialog(this, gProgname);
  385.     gSystem->AddSignalHandler(new ApplIntHandler);
  386.     gClassManager->SetDynLoadHook(this, (OObjMemberFunc)&Application::DynLoad);
  387.  
  388.     gClipBoard= clipboard= gWindowSystem->MakeClipboard();
  389.     
  390.     OpenApplicationDialog(GetNewDocumentPos());
  391.     
  392.     gSystem->Control();
  393.     
  394.     SafeDelete(clipboard);
  395.     gClipBoard= 0;
  396.  
  397.     applDialog->Close();
  398.     
  399.     return 0;
  400. }
  401.  
  402. void Application::OpenApplicationDialog(Point p)
  403. {
  404.     applDialog->ShowAt(0, p);
  405. }
  406.  
  407. int Application::DynLoad(char *name)
  408. {
  409.     Object *op= gSystem->Load(gProgname, name);
  410.     if (op == 0) {
  411.     Error("DynLoad", "cannot load class");
  412.     return 0;
  413.     }
  414.     return DynLoadHook(op);
  415. }
  416.  
  417. int Application::DynLoadHook(Object*)
  418. {
  419.     return 1;
  420. }
  421.  
  422. VObject *Application::DoCreateDialog() 
  423. { 
  424.     return new BorderItem(
  425.         new Expander(cIdNone, eHor, 5,
  426.             new ActionButton(cNEW,  "new"),
  427.             new ActionButton(cOPEN, "open"),
  428.             new ActionButton(cQUIT, "quit"),
  429.             0
  430.         ),
  431.         Point(5)
  432.         );
  433. }
  434.  
  435. void Application::ShowApplicationWindow()
  436. {
  437.     if (applDialog)
  438.     applDialog->GetWindow()->Open();    
  439. }
  440.  
  441. void Application::InspectorId(char *buf, int sz)
  442. {
  443.     strn0cpy(buf, argv[0], sz);
  444. }
  445.  
  446. void Application::Parts(Collection* col)
  447. {
  448.     EvtHandler::Parts(col);
  449.     col->AddVector(documents, applDialog, 0);
  450. }
  451.  
  452. void Application::UpdateGlobals()
  453. {
  454.     extern IdDictionary *ObjectGetObservers();
  455.     
  456.     gApplication= this;
  457.     gClassManager= ::gClassManager;
  458.     gWindow= ::gWindow;
  459.     gDebug= ::gDebug;
  460.     gBatch= ::gBatch;
  461.     gScreenRect= ::gScreenRect;
  462.     gObservers= ObjectGetObservers();
  463.     gEnviron= environ;
  464. }
  465.  
  466. void Application::DoOnError(int level, char *location, char *msg)
  467. {
  468.     int ignorelevel= GetIgnoreLevel();
  469.     static bool inError= FALSE;
  470.     
  471.     if (level < ignorelevel || inError)
  472.     return;
  473.     inError= TRUE;
  474.     
  475.     char *type= "Warning";
  476.     if (level >= cFatal)
  477.     type= "Fatal";
  478.     else if (level >= cSysError)
  479.     type= "SysError";
  480.     else if (level >= cError)
  481.     type= "Error";
  482.     
  483.     cerr.form("%s: %s in <%s>: %s\n", ProgramName(), type, location, msg);
  484.     if (level >= cError) {
  485.     switch (ShowAlert(eAlertError, "%s: %s\nin @B%s@B: %s", ProgramName(), type, location, msg)) {
  486.     case cIdIgnore:
  487.         break;
  488.         
  489.     case cIdAbort:
  490.         Abort();
  491.         
  492.     case cIdInspect:
  493.         Inspect();
  494.         break;
  495.     }
  496.     }
  497.     inError= FALSE;
  498. }
  499.  
  500.